package com.opc.quarz;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.opc.Common.MessageConstant;
import com.opc.Mapper.*;
import com.opc.Pojo.*;
import com.opc.properties.CarTypeProperties;
import com.opc.websocket.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.util.*;

@Component
@DisallowConcurrentExecution // 确保任务不会并发执行
@Slf4j
public class TorqueCheckExport extends QuartzJobBean {
    @Value("${historyData.samplePath}")//必须是org.springframework.beans.factory.annotation提供的Value
    private String basePath;
    @Autowired
    private CarTypeProperties carTypeProperties;
    @Autowired
    private WebSocketServer webSocketServer;
//    @Qualifier("carStatusService")
    @Autowired
    private SampleScrewMapper sampleScrewMapper;

    // 声明Logger对象
//    private static final Logger logger =
//            LoggerFactory.getLogger(TorqueCheckExport.class);


    private static String convertLocalDateTimeToString(Date Time) {
        LocalDateTime localDateTime = Time.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
        String formattedTime = String.format("%04d:%02d:%02d:%02d:%02d:%02d",
                localDateTime.getYear(),
                localDateTime.getMonthValue(),
                localDateTime.getDayOfMonth(),
                localDateTime.getHour(),
                localDateTime.getMinute(),
                localDateTime.getSecond());
//        log.info("formattedTime是"+formattedTime);
        // 使用 replace() 方法替换第一个 ':' 为 '-'
        // 使用正则表达式替换前两个 ':' 为 '-'
        // 拆分字符串
        String[] parts = formattedTime.split(":");
        // 重新组装字符串
        String newFormattedTime = String.join("-", parts[0], parts[1]) + "-" + parts[2] + " " + parts[3] + ":" + parts[4] + ":" + parts[5];
//        log.info("timeFormatter是"+newFormattedTime);
        return newFormattedTime;
    }

    private void createDirectoryIfNotExists(String directoryPath) {
        Path path = Paths.get(directoryPath);
        // 检查目录是否存在
        if (!Files.exists(path)) {
            try {
                // 创建目录（包括必要的父目录）
                Files.createDirectories(path);
                log.info("目录已创建: " + directoryPath);
            } catch (IOException e) {
                System.err.println("无法创建目录: " + e.getMessage());
                if(e.getMessage().contains("Unable to determine if root directory exists")){
                    log.info("创建文件夹失败，没有这个盘");
                    Map map = new HashMap<>();
                    int colonIndex = basePath.indexOf(':');
                    if (colonIndex != -1) {
                        String result = basePath.substring(0, colonIndex);
                        map.put("message", "创建备份目录失败，找不到磁盘"+result);
                    }
                    String json = JSON.toJSONString(map);
                    webSocketServer.sendToAllClient(json);
                }
            }
        } else {
            log.info("目录已存在: " + directoryPath);
        }
    }

    //旧的写excel方法，取样8次
    private int processCarType(String carType, String month, String basePath) {
        System.out.println("自动导出excel");
        log.info("自动导出excel");
        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);

        if (sampleScrews.isEmpty()) {
            log.info("没有找到前个月的" + carType + "车型");
            System.out.println("没有找到前个月的" + carType + "车型");
            return 0;
        }

        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
        InputStream in = null;
        if(carType.equals(carTypeProperties.getCamry())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+MessageConstant.camryFileName);
        }else if(carType.equals(carTypeProperties.getLevin())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+MessageConstant.levinFileName);
        }else {
            log.info("未知车型");
            return -1;
        }
        //基于模板文件创建Excel文件
        //旧格式
        HSSFWorkbook excel = null;
        //新格式
//        XSSFWorkbook excel = null;
        try {
            POIFSFileSystem fs = new POIFSFileSystem(in);
            excel = new HSSFWorkbook(fs);
            //新格式
//            excel = new XSSFWorkbook(in);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        HSSFSheet YQSheet = excel.getSheet("右前门扭力");
        HSSFSheet ZQSheet = excel.getSheet("左前门扭力");
        HSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
        HSSFSheet ZHSheet = excel.getSheet("左后门扭力");
        HSSFSheet CGSheet = excel.getSheet("发动机盖");

        if(carType.equals(carTypeProperties.getCamry())) {

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts0 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {//循环这一堆样本数据

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 17; // 每个screwTypeId占据17行
                //rowOffset是上一堆4行填充数据距离下一堆4行填充数据的间隔距离，是能够一堆一堆(4行)地填充进去的原因
                //filledCounts[day][screwTypeId]是1到4，是能够一行一行地填充进去的原因
                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第17行开始填充，加上偏移量

                // 检查是否已经填充了4个数据
                if (filledCounts[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
//                int rowNumber0 = 71 + filledCounts0[day][carNum]; // 从第71行开始填充，加上偏移量

//                // 检查是否已经填充了4个车身号数据
//                if (filledCounts0[day][carNum] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = ZHSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = ZQSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getCarNum());
//
//                    // 增加已填充计数
//                    filledCounts0[day][carNum]++;
//                }

                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts0.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = ZQSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts0.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }


            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts02 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts02.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = ZHSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts02.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }

            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts03 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts03.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = YQSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts03.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }

            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts04 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts04.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = YHSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts04.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts05 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 15; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 2) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第64到65行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第64到65行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts05.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 2) {
                    int rowNumber0 = 63 + currentCount;
                    Row row = CGSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts05.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }
            }

        }
        else if(carType.equals(carTypeProperties.getLevin())) {
            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
                if (filledCounts[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque());// + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }
            }
        }else {
            log.info("未知车型");
            return -1;
        }


        String Path = basePath + "\\";
        // 确保目录存在，如果不存在则创建
        createDirectoryIfNotExists(Path);
        String filePath = null;
        if(carType.equals(carTypeProperties.getCamry())){
            filePath = Path + "(" + month + ")" + MessageConstant.camryFileName; // 指定路径，同名就会会覆盖之前生成的文件
        }else if(carType.equals(carTypeProperties.getLevin())){
            filePath = Path + "(" + month + ")" + MessageConstant.levinFileName;
        }

        try (FileOutputStream fileOutputStream = new FileOutputStream(filePath)) {
            excel.write(fileOutputStream); // 写入数据
            log.info(carType + "车型的抽样Excel文件已成功导出到: " + filePath);
            return 1;
        } catch (IOException e) {
            log.info("导出" + carType + "车型的Excel文件时出错: " + e.getMessage());
            return -1;
        } finally {
            try {
                excel.close(); // 关闭工作簿
            } catch (IOException e) {
                log.info("关闭" + carType + "车型的工作簿时出错: " + e.getMessage());
                return -1;
            }
        }
    }

    @Override
    @Transactional
    @Async
    public void executeInternal(JobExecutionContext context) {
        LocalDate today = LocalDate.now();
        YearMonth currentYearMonth = YearMonth.from(today);
        YearMonth previousYearMonth = currentYearMonth.minusMonths(1);
        log.info("前一个月是："+previousYearMonth);
        String month = previousYearMonth.toString();
        // 处理凯美瑞车型
        int result1 = processCarType(carTypeProperties.getCamry(), month, basePath);

        // 处理雷凌车型的数据
        int result2 = processCarType(carTypeProperties.getLevin(), month, basePath);

        LambdaQueryWrapper<SampleScrew> queryWrapper = new LambdaQueryWrapper<>();
//        YearMonth previouspreviousYearMonth = previousYearMonth.minusMonths(1);
//        System.out.println("previouspreviousYearMonth是"+previouspreviousYearMonth);
        System.out.println("previousYearMonth是"+month);
        LocalDate firstDayOfMonth = previousYearMonth.atDay(1);
        System.out.println("firstDayOfMonth是"+firstDayOfMonth);
        queryWrapper.le(SampleScrew::getScrewCreateTime, firstDayOfMonth);
        if (result1 == 1 && result2 == 1) {
            //清空上上个月的整个表
            sampleScrewMapper.delete(queryWrapper);
//            logger.info("清空了所有样本");
            log.info("清空了所有样本");
        }else if (result1 == -1 || result2 == -1) {
//            logger.error("excel表样本数据导出失败");
            log.info("excel表样本数据导出失败");
        } else if(result1 == 0 && result2 == 0) {
            log.info("没有需要备份的数据");
        } else if(result1 == 1 || result2 == 0) {
            log.info("没有找到雷凌车型的数据");
            sampleScrewMapper.delete(queryWrapper);
        } else if(result1 == 0 || result2 == 1) {
            log.info("没有找到凯美瑞车型的数据");
            sampleScrewMapper.delete(queryWrapper);
        } else {
            log.info("excel表样本数据导出位置错误");
        }

//        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
//        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
//        querySampleScrewWrapper.eq(SampleScrew::getCarType, carTypeProperties.getCamry());
//        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);
//
//
//        //获取前一个月的所
//        //从类加载器中获取模板文件
//        if(sampleScrews.isEmpty()){
//            log.info("没有找到前个月的凯美瑞车型");
//            return;
//        }
//        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
//        InputStream in = this.getClass().getClassLoader()
//                .getResourceAsStream("template/381DSB1线四门工程扭力检查表 (完).xls");
//
//        //基于模板文件创建Excel文件
//        //旧格式
//        HSSFWorkbook excel = null;
//        //新格式
////        XSSFWorkbook excel = null;
//        try {
//            POIFSFileSystem fs = new POIFSFileSystem(in);
//            excel = new HSSFWorkbook(fs);
//            //新格式
////            excel = new XSSFWorkbook(in);
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//        HSSFSheet YQSheet = excel.getSheet("右前门扭力");
//        HSSFSheet ZQSheet = excel.getSheet("左前门扭力");
//        HSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
//        HSSFSheet ZHSheet = excel.getSheet("左后门扭力");
//        HSSFSheet CGSheet = excel.getSheet("发动机盖");
//
//        // 用于跟踪每天每种ScrewTypeId已填充的数量
//        int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//        //处理左前后门数据
//        for (SampleScrew sampleScrew : sampleScrews) {
//
//            String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//            int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//            int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//            String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//            int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//            int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//            // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//            if (screwTypeId >= 5) {
//                continue;
//            }
//
//            // 计算行号和列号
//            int rowOffset = (screwTypeId - 1) * 27; // 每个screwTypeId占据27行
//            int rowNumber = 22 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//            // 检查是否已经填充了8个数据
//            if (filledCounts[day][screwTypeId] < 8) {
//                // 获取或创建行和单元格
//                Row row = ZQSheet.getRow(rowNumber);
//                if (row == null) {
//                    row = ZQSheet.createRow(rowNumber);
//                }
//
//                int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                Cell cell = row.getCell(columnNumber);
//                if (cell == null) {
//                    cell = row.createCell(columnNumber);
//                }
//
//                // 填充数据
//                cell.setCellValue(sampleScrew.getTorque()+ "\n" +sampleScrew.getUnit());
//
//                // 增加已填充计数
//                filledCounts[day][screwTypeId]++;
//            }
//        }
//
//        // 用于跟踪每天每种ScrewTypeId已填充的数量
//        int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//        //处理左后门数据
//        for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//            String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//            int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//            int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//            String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//            int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//            int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//            // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//            if (screwTypeId <= 4 || screwTypeId >= 9) {
//                continue;
//            }
//
//            // 计算行号和列号
//            int rowOffset = (screwTypeId - 5) * 27; // 每个screwTypeId占据27行
//            int rowNumber = 22 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//            // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
//            if (filledCounts2[day][screwTypeId] < 8) {
//                // 获取或创建行和单元格
//                Row row = ZHSheet.getRow(rowNumber);
////                log.info("第几行"+rowNumber);
//                if (row == null) {
//                    row = ZHSheet.createRow(rowNumber);
//                }
//
//                int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                Cell cell = row.getCell(columnNumber);
//                if (cell == null) {
//                    cell = row.createCell(columnNumber);
//                }
//
//                // 填充数据
//                cell.setCellValue(sampleScrew.getTorque()+ "\n" +sampleScrew.getUnit());
//
//                // 增加已填充计数
//                filledCounts2[day][screwTypeId]++;
//            }
//        }
//
//        // 用于跟踪每天每种ScrewTypeId已填充的数量
//        int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//        //处理右前门数据
//        for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//            String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//            int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//            int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//            String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//            int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//            int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//            // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//            if (screwTypeId <= 8 || screwTypeId >= 13) {
//                continue;
//            }
//
//            // 计算行号和列号
//            int rowOffset = (screwTypeId - 9) * 27; // 每个screwTypeId占据27行
//            int rowNumber = 22 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//            // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
//            if (filledCounts3[day][screwTypeId] < 8) {
//                // 获取或创建行和单元格
//                Row row = YQSheet.getRow(rowNumber);
////                log.info("第几行"+rowNumber);
//                if (row == null) {
//                    row = YQSheet.createRow(rowNumber);
//                }
//
//                int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                Cell cell = row.getCell(columnNumber);
//                if (cell == null) {
//                    cell = row.createCell(columnNumber);
//                }
//
//                // 填充数据
//                cell.setCellValue(sampleScrew.getTorque()+ "\n" +sampleScrew.getUnit());
//
//                // 增加已填充计数
//                filledCounts3[day][screwTypeId]++;
//            }
//        }
//
//        // 用于跟踪每天每种ScrewTypeId已填充的数量
//        int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//        //处理右后门数据
//        for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//            String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//            int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//            int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//            String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//            int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//            int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//            // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//            if (screwTypeId <= 12 || screwTypeId >= 17) {
//                continue;
//            }
//
//            // 计算行号和列号
//            int rowOffset = (screwTypeId - 13) * 27; // 每个screwTypeId占据27行
//            int rowNumber = 22 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//            // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts4[day][screwTypeId]);
//            if (filledCounts4[day][screwTypeId] < 8) {
//                // 获取或创建行和单元格
//                Row row = YHSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
//                if (row == null) {
//                    row = YHSheet.createRow(rowNumber);
//                }
//
//                int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                Cell cell = row.getCell(columnNumber);
//                if (cell == null) {
//                    cell = row.createCell(columnNumber);
//                }
//
//                // 填充数据
//                cell.setCellValue(sampleScrew.getTorque()+ "\n" +sampleScrew.getUnit());
//
//                // 增加已填充计数
//                filledCounts4[day][screwTypeId]++;
//            }
//        }
//
//        // 用于跟踪每天每种ScrewTypeId已填充的数量
//        int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//        //处理车盖数据
//        for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//            String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//            int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//            int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//            String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//            int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//            int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//            // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//            if (screwTypeId <= 16 || screwTypeId >= 21) {
//                continue;
//            }
//
//            // 计算行号和列号
//            int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
//            int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量
//
//            // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts5[day][screwTypeId]);
//            if (filledCounts5[day][screwTypeId] < 8) {
//                // 获取或创建行和单元格
//                Row row = CGSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
//                if (row == null) {
//                    row = CGSheet.createRow(rowNumber);
//                }
//
//                int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                Cell cell = row.getCell(columnNumber);
//                if (cell == null) {
//                    cell = row.createCell(columnNumber);
//                }
//
//                // 填充数据
//                cell.setCellValue(sampleScrew.getTorque()+ "\n" +sampleScrew.getUnit());
//
//                // 增加已填充计数
//                filledCounts5[day][screwTypeId]++;
//            }
//        }

//        String Path = basePath+"\\";
//        // 确保目录存在，如果不存在则创建
//        createDirectoryIfNotExists(Path);
//        String filePath = Path + "(" + month +")"+ "381DSB1线四门工程扭力检查表 (完).xls"; // 指定路径，同名就会会覆盖之前生成的文件
//
//        try (FileOutputStream fileOutputStream = new FileOutputStream(filePath)) {
//            excel.write(fileOutputStream); // 写入数据
//            log.info("Excel文件已成功导出到: " + filePath);
//        } catch (IOException e) {
//            log.info("导出Excel文件时出错: " + e.getMessage());
//        } finally {
//            try {
//                excel.close(); // 关闭工作簿
//            } catch (IOException e) {
//                log.info("关闭工作簿时出错: " + e.getMessage());
//            }
//        }
    }
}
